{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Building Noise Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "This notebook introduces how to use the Qiskit Aer `noise` module to build custom noise models for noisy simulations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.403378Z",
     "start_time": "2019-08-19T17:00:41.139269Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit import QuantumCircuit, transpile\n",
    "from qiskit.quantum_info import Kraus, SuperOp\n",
    "from qiskit.providers.aer import AerSimulator\n",
    "from qiskit.tools.visualization import plot_histogram\n",
    "\n",
    "# Import from Qiskit Aer noise module\n",
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise import QuantumError, ReadoutError\n",
    "from qiskit.providers.aer.noise import pauli_error\n",
    "from qiskit.providers.aer.noise import depolarizing_error\n",
    "from qiskit.providers.aer.noise import thermal_relaxation_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Qiskit Aer Noise Module\n",
    "\n",
    "The Qiskit Aer `noise` module contains Python classes to build customized noise models for simulation. There are three key classes:\n",
    "\n",
    "1. The `NoiseModel` class which stores a noise model used for noisy simulation.\n",
    "2. The `QuantumError` class which describes CPTP gate errors. These can be applied:\n",
    "    * After *gate* or *reset* instructions\n",
    "    * Before *measure* instructions.\n",
    "\n",
    "3. The `ReadoutError` class which describes classical readout errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Errors\n",
    "\n",
    "Rather than deal with the `QuantumError` object directly, many helper functions exist to automatically generate a specific type of parameterized quantum error. These are contained in the `noise` module and include functions for many common errors types used in quantum computing research. The function names and the type of error they return are:\n",
    "\n",
    "| Standard error function | Details |\n",
    "| --- | --- |\n",
    "| `kraus_error` | a general n-qubit CPTP error channel given as a list of Kraus matrices $[K_0, ...]$. |\n",
    "| `mixed_unitary_error` | an n-qubit mixed unitary error given as a list of unitary matrices and probabilities $[(U_0, p_0),...]$. |\n",
    "| `coherent_unitary_error` | an n-qubit coherent unitary error given as a single unitary matrix $U$. |\n",
    "| `pauli_error` | an n-qubit Pauli error channel (mixed unitary) given as a list of Pauli's and probabilities $[(P_0, p_0),...]$ |\n",
    "| `depolarizing_error` | an n-qubit depolarizing error channel parameterized by a depolarization probability $p$. |\n",
    "| `reset_error` | a single-qubit reset error parameterized by a probabilities $p_0, p_1$ of resetting to the $|0\\rangle$, $|1\\rangle$ state.|\n",
    "| `thermal_relaxation_error` | a single qubit thermal relaxation channel parameterized by relaxation time constants $T_1$, $T_2$, gate time $t$, and excited state thermal population $p_1$. |\n",
    "| `phase_amplitude_damping_error` | A single-qubit generalized combined phase and amplitude damping error channel given by an amplitude damping parameter $\\lambda$, a phase damping parameter $\\gamma$, and an excited state thermal population $p_1$. |\n",
    "| `amplitude_damping_error` |  A single-qubit generalized amplitude damping error channel given by an amplitude damping parameter $\\lambda$, and an excited state thermal population $p_1$. |\n",
    "| `phase_damping_error` |  A single-qubit phase damping error channel given by a phase damping parameter $\\gamma$ |\n",
    "\n",
    "### Combining quantum errors\n",
    "\n",
    "`QuantumError` instances can be combined by using composition, tensor product, and tensor expansion (reversed order tensor product) to produce new `QuantumErrors` as:\n",
    "\n",
    " * Composition: $\\cal{E}(\\rho)=\\cal{E_2}(\\cal{E_1}(\\rho))$ as `error = error1.compose(error2)`\n",
    " * Tensor product: $\\cal{E}(\\rho) =(\\cal{E_1}\\otimes\\cal{E_2})(\\rho)$ as `error error1.tensor(error2)`\n",
    " * Expand product: $\\cal{E}(\\rho) =(\\cal{E_2}\\otimes\\cal{E_1})(\\rho)$ as `error error1.expand(error2)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "For example to construct a 5% single-qubit Bit-flip error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.420358Z",
     "start_time": "2019-08-19T17:00:43.416062Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.05, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(1) = 0.95, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n",
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.05, QasmQobjInstructions = [[{'name': 'z', 'qubits': [0]}]\n",
      "  P(1) = 0.95, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n"
     ]
    }
   ],
   "source": [
    "# Construct a 1-qubit bit-flip and phase-flip errors\n",
    "p_error = 0.05\n",
    "bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])\n",
    "phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])\n",
    "print(bit_flip)\n",
    "print(phase_flip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.435843Z",
     "start_time": "2019-08-19T17:00:43.432211Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.0025000000000000005, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}, {'name': 'z', 'qubits': [0]}]\n",
      "  P(1) = 0.0475, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(2) = 0.0475, QasmQobjInstructions = [[{'name': 'z', 'qubits': [0]}]\n",
      "  P(3) = 0.9025, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n"
     ]
    }
   ],
   "source": [
    "# Compose two bit-flip and phase-flip errors\n",
    "bitphase_flip = bit_flip.compose(phase_flip)\n",
    "print(bitphase_flip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.460191Z",
     "start_time": "2019-08-19T17:00:43.456782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 2 qubits. Noise circuits:\n",
      "  P(0) = 0.0025000000000000005, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}, {'name': 'z', 'qubits': [1]}]\n",
      "  P(1) = 0.0475, QasmQobjInstructions = [[{'name': 'z', 'qubits': [1]}]\n",
      "  P(2) = 0.0475, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(3) = 0.9025, QasmQobjInstructions = [[{'name': 'id', 'qubits': [1]}]\n"
     ]
    }
   ],
   "source": [
    "# Tensor product two bit-flip and phase-flip errors with\n",
    "# bit-flip on qubit-0, phase-flip on qubit-1\n",
    "error2 = phase_flip.tensor(bit_flip)\n",
    "print(error2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting to and from QuantumChannel operators\n",
    " \n",
    "We can also convert back and forth between `QuantumError` objects in Qiskit Aer and `QuantumChannel` objects in Qiskit Terra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.482424Z",
     "start_time": "2019-08-19T17:00:43.473779Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus([[[ 9.74679434e-01+0.j,  0.00000000e+00+0.j],\n",
      "        [ 0.00000000e+00+0.j,  9.74679434e-01+0.j]],\n",
      "\n",
      "       [[ 0.00000000e+00+0.j,  2.23606798e-01+0.j],\n",
      "        [ 2.23606798e-01+0.j, -4.96506831e-17+0.j]]],\n",
      "      input_dims=(2,), output_dims=(2,))\n"
     ]
    }
   ],
   "source": [
    "# Convert to Kraus operator\n",
    "bit_flip_kraus = Kraus(bit_flip)\n",
    "print(bit_flip_kraus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.509521Z",
     "start_time": "2019-08-19T17:00:43.503976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SuperOp([[1. +0.j, 0. +0.j, 0. +0.j, 0. +0.j],\n",
      "         [0. +0.j, 0.9+0.j, 0. +0.j, 0. +0.j],\n",
      "         [0. +0.j, 0. +0.j, 0.9+0.j, 0. +0.j],\n",
      "         [0. +0.j, 0. +0.j, 0. +0.j, 1. +0.j]],\n",
      "        input_dims=(2,), output_dims=(2,))\n"
     ]
    }
   ],
   "source": [
    "# Convert to Superoperator\n",
    "phase_flip_sop = SuperOp(phase_flip)\n",
    "print(phase_flip_sop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:43.794037Z",
     "start_time": "2019-08-19T17:00:43.778223Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantumError on 1 qubits. Noise circuits:\n",
      "  P(0) = 0.04999999999999995, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]\n",
      "  P(1) = 0.9500000000000002, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert back to a quantum error\n",
    "print(QuantumError(bit_flip_kraus))\n",
    "\n",
    "# Check conversion is equivalent to original error\n",
    "QuantumError(bit_flip_kraus) == bit_flip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Readout Error\n",
    "\n",
    "Classical readout errors are specified by a list of assignment probabilities vectors $P(A|B)$:\n",
    "\n",
    "  * $A$ is the *recorded* classical bit value\n",
    "  * $B$ is the *true* bit value returned from the measurement \n",
    " \n",
    "E.g. for 1 qubits: $ P(A|B) = [P(A|0), P(A|1)]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:44.659598Z",
     "start_time": "2019-08-19T17:00:44.654818Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ReadoutError([[0.95 0.05]\n",
       " [0.1  0.9 ]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Measurement miss-assignement probabilities\n",
    "p0given1 = 0.1\n",
    "p1given0 = 0.05\n",
    "\n",
    "ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Readout errors may also be combined using `compose`, `tensor` and `expand` like with quantum errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding errors to a Noise Model\n",
    "\n",
    "When adding a quantum error to a noise model we must specify the type of *instruction* that it acts on, and what qubits to apply it to. There are three cases for Quantum Errors:\n",
    " \n",
    " 1. All-qubit quantum error\n",
    " 2. Specific qubit quantum error\n",
    " 3. Non-local quantum error\n",
    " \n",
    "### All-qubit quantum error\n",
    "\n",
    "This applies the same error to any occurrence of an instruction, regardless of which qubits it acts on.\n",
    "\n",
    "It is added as `noise_model.add_all_qubit_quantum_error(error, instructions)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:45.882254Z",
     "start_time": "2019-08-19T17:00:45.877630Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['u3', 'u2', 'u1']\n",
      "  All-qubits errors: ['u1', 'u2', 'u3']\n"
     ]
    }
   ],
   "source": [
    "# Create an empty noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "# Add depolarizing error to all single qubit u1, u2, u3 gates\n",
    "error = depolarizing_error(0.05, 1)\n",
    "noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])\n",
    "\n",
    "# Print noise model info\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specific qubit quantum error\n",
    "\n",
    "This applies the error to any occurrence of an instruction acting on a specified list of qubits. Note that the order of the qubit matters: For a 2-qubit gate an error applied to qubits [0, 1] is different to one applied to qubits [1, 0] for example.\n",
    "\n",
    "It is added as `noise_model.add_quantum_error(error, instructions, qubits)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:46.615959Z",
     "start_time": "2019-08-19T17:00:46.612055Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['u3', 'u2', 'u1']\n",
      "  Qubits with noise: [0]\n",
      "  Specific qubit errors: [('u1', [0]), ('u2', [0]), ('u3', [0])]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "# Add depolarizing error to all single qubit u1, u2, u3 gates on qubit 0 only\n",
    "error = depolarizing_error(0.05, 1)\n",
    "noise_model.add_quantum_error(error, ['u1', 'u2', 'u3'], [0])\n",
    "\n",
    "# Print noise model info\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-local qubit quantum error\n",
    "\n",
    "This applies an error to a specific set of noise qubits after any occurrence of an instruction acting on a specific of gate qubits.\n",
    "\n",
    "It is added as `noise_model.add_nonlocal_quantum_error(error, instructions, instr_qubits, error_qubits)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:47.444879Z",
     "start_time": "2019-08-19T17:00:47.440612Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['u3', 'u2', 'u1']\n",
      "  Qubits with noise: [0, 2]\n",
      "  Non-local specific qubit errors: [('u1', [0], [2]), ('u2', [0], [2]), ('u3', [0], [2])]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "# Add depolarizing error on qubit 2 forall single qubit u1, u2, u3 gates on qubit 0 \n",
    "error = depolarizing_error(0.05, 1)\n",
    "noise_model.add_nonlocal_quantum_error(error, ['u1', 'u2', 'u3'], [0], [2])\n",
    "\n",
    "# Print noise model info\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing a noisy simulation with a noise model\n",
    "\n",
    "The command `AerSimulator(noise_model=noise_model)` returns a simulator configured to the given noise model. In addition to setting the simulator's noise model, it also overrides the simulator's basis gates, according to the gates of the noise model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Noise Model Examples\n",
    "\n",
    "We will now give some examples of noise models. For our demonstrations we will use a simple test circuit generating a n-qubit GHZ state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:48.817405Z",
     "start_time": "2019-08-19T17:00:48.806966Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐                ░ ┌─┐         \n",
      "   q_0: ┤ H ├──■─────────────░─┤M├─────────\n",
      "        └───┘┌─┴─┐           ░ └╥┘┌─┐      \n",
      "   q_1: ─────┤ X ├──■────────░──╫─┤M├──────\n",
      "             └───┘┌─┴─┐      ░  ║ └╥┘┌─┐   \n",
      "   q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───\n",
      "                  └───┘┌─┴─┐ ░  ║  ║ └╥┘┌─┐\n",
      "   q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├\n",
      "                       └───┘ ░  ║  ║  ║ └╥┘\n",
      "meas: 4/════════════════════════╩══╩══╩══╩═\n",
      "                                0  1  2  3 \n"
     ]
    }
   ],
   "source": [
    "# System Specification\n",
    "n_qubits = 4\n",
    "circ = QuantumCircuit(n_qubits)\n",
    "\n",
    "# Test Circuit\n",
    "circ.h(0)\n",
    "for qubit in range(n_qubits - 1):\n",
    "    circ.cx(qubit, qubit + 1)\n",
    "circ.measure_all()\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ideal Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:50.560988Z",
     "start_time": "2019-08-19T17:00:50.415545Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ideal simulator and execution\n",
    "sim_ideal = AerSimulator()\n",
    "result_ideal = sim_ideal.run(circ).result()\n",
    "plot_histogram(result_ideal.get_counts(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Noise Example 1: Basic bit-flip error noise model\n",
    "\n",
    "Lets consider a simple toy noise model example common in quantum information theory research:\n",
    "\n",
    "* When applying a single qubit gate, flip the state of the qubit with probability `p_gate1`.\n",
    "* When applying a 2-qubit gate apply single-qubit errors to each qubit.\n",
    "* When resetting a qubit reset to 1 instead of 0 with probability `p_reset`.\n",
    "* When measuring a qubit, flip the state of the qubit with probability `p_meas`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:51.543615Z",
     "start_time": "2019-08-19T17:00:51.536564Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']\n",
      "  Instructions with noise: ['reset', 'u3', 'cx', 'u2', 'u1', 'measure']\n",
      "  All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']\n"
     ]
    }
   ],
   "source": [
    "# Example error probabilities\n",
    "p_reset = 0.03\n",
    "p_meas = 0.1\n",
    "p_gate1 = 0.05\n",
    "\n",
    "# QuantumError objects\n",
    "error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])\n",
    "error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n",
    "error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])\n",
    "error_gate2 = error_gate1.tensor(error_gate1)\n",
    "\n",
    "# Add errors to noise model\n",
    "noise_bit_flip = NoiseModel()\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_reset, \"reset\")\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_meas, \"measure\")\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n",
    "noise_bit_flip.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n",
    "\n",
    "print(noise_bit_flip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing the noisy simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:52.951874Z",
     "start_time": "2019-08-19T17:00:52.687440Z"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create noisy simulator backend\n",
    "sim_noise = AerSimulator(noise_model=noise_bit_flip)\n",
    "\n",
    "# Transpile circuit for noisy basis gates\n",
    "circ_tnoise = transpile(circ, sim_noise)\n",
    "\n",
    "# Run and get counts\n",
    "result_bit_flip = sim_noise.run(circ_tnoise).result()\n",
    "counts_bit_flip = result_bit_flip.get_counts(0)\n",
    "\n",
    "# Plot noisy output\n",
    "plot_histogram(counts_bit_flip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: T1/T2 thermal relaxation\n",
    "\n",
    "Now consider a more realistic error model based on thermal relaxation with the qubit environment:\n",
    "* Each qubit is parameterized by a thermal relaxation time constant $T_1$ and a dephasing time constant $T_2$.\n",
    "* Note that we must have $T_2 \\le 2 T_1$.\n",
    "* Error rates on instructions are determined by gate times and qubit $T_1$, $T_2$ values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:54.577456Z",
     "start_time": "2019-08-19T17:00:54.491018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'u2', 'u3']\n",
      "  Instructions with noise: ['reset', 'cx', 'u3', 'u2', 'measure']\n",
      "  Qubits with noise: [0, 1, 2, 3]\n",
      "  Specific qubit errors: [('reset', [0]), ('reset', [1]), ('reset', [2]), ('reset', [3]), ('measure', [0]), ('measure', [1]), ('measure', [2]), ('measure', [3]), ('u2', [0]), ('u2', [1]), ('u2', [2]), ('u2', [3]), ('u3', [0]), ('u3', [1]), ('u3', [2]), ('u3', [3]), ('cx', [0, 0]), ('cx', [0, 1]), ('cx', [0, 2]), ('cx', [0, 3]), ('cx', [1, 0]), ('cx', [1, 1]), ('cx', [1, 2]), ('cx', [1, 3]), ('cx', [2, 0]), ('cx', [2, 1]), ('cx', [2, 2]), ('cx', [2, 3]), ('cx', [3, 0]), ('cx', [3, 1]), ('cx', [3, 2]), ('cx', [3, 3])]\n"
     ]
    }
   ],
   "source": [
    "# T1 and T2 values for qubits 0-3\n",
    "T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec\n",
    "T2s = np.random.normal(70e3, 10e3, 4)  # Sampled from normal distribution mean 50 microsec\n",
    "\n",
    "# Truncate random T2s <= T1s\n",
    "T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])\n",
    "\n",
    "# Instruction times (in nanoseconds)\n",
    "time_u1 = 0   # virtual gate\n",
    "time_u2 = 50  # (single X90 pulse)\n",
    "time_u3 = 100 # (two X90 pulses)\n",
    "time_cx = 300\n",
    "time_reset = 1000  # 1 microsecond\n",
    "time_measure = 1000 # 1 microsecond\n",
    "\n",
    "# QuantumError objects\n",
    "errors_reset = [thermal_relaxation_error(t1, t2, time_reset)\n",
    "                for t1, t2 in zip(T1s, T2s)]\n",
    "errors_measure = [thermal_relaxation_error(t1, t2, time_measure)\n",
    "                  for t1, t2 in zip(T1s, T2s)]\n",
    "errors_u1  = [thermal_relaxation_error(t1, t2, time_u1)\n",
    "              for t1, t2 in zip(T1s, T2s)]\n",
    "errors_u2  = [thermal_relaxation_error(t1, t2, time_u2)\n",
    "              for t1, t2 in zip(T1s, T2s)]\n",
    "errors_u3  = [thermal_relaxation_error(t1, t2, time_u3)\n",
    "              for t1, t2 in zip(T1s, T2s)]\n",
    "errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(\n",
    "             thermal_relaxation_error(t1b, t2b, time_cx))\n",
    "              for t1a, t2a in zip(T1s, T2s)]\n",
    "               for t1b, t2b in zip(T1s, T2s)]\n",
    "\n",
    "# Add errors to noise model\n",
    "noise_thermal = NoiseModel()\n",
    "for j in range(4):\n",
    "    noise_thermal.add_quantum_error(errors_reset[j], \"reset\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_measure[j], \"measure\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_u1[j], \"u1\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_u2[j], \"u2\", [j])\n",
    "    noise_thermal.add_quantum_error(errors_u3[j], \"u3\", [j])\n",
    "    for k in range(4):\n",
    "        noise_thermal.add_quantum_error(errors_cx[j][k], \"cx\", [j, k])\n",
    "\n",
    "print(noise_thermal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing the noisy simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:00:55.689241Z",
     "start_time": "2019-08-19T17:00:55.515394Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the noisy simulation\n",
    "sim_thermal = AerSimulator(noise_model=noise_thermal)\n",
    "\n",
    "# Transpile circuit for noisy basis gates\n",
    "circ_tthermal = transpile(circ, sim_thermal)\n",
    "\n",
    "# Run and get counts\n",
    "result_thermal = sim_thermal.run(circ_tthermal).result()\n",
    "counts_thermal = result_thermal.get_counts(0)\n",
    "\n",
    "# Plot noisy output\n",
    "plot_histogram(counts_thermal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:01:16.716582Z",
     "start_time": "2019-08-19T17:01:16.709462Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>0.25.0</td></tr><tr><td>Terra</td><td>0.17.0</td></tr><tr><td>Aer</td><td>0.8.0</td></tr><tr><td>Ignis</td><td>0.6.0</td></tr><tr><td>Aqua</td><td>0.9.0</td></tr><tr><td>IBM Q Provider</td><td>0.12.2</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.7 (default, May  6 2020, 04:59:01) \n",
       "[Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>6</td></tr><tr><td>Memory (Gb)</td><td>32.0</td></tr><tr><td colspan='2'>Fri Apr 02 12:05:34 2021 EDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2021.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
